// function identity<Type>(arg: Type): Type {
//     return arg;
// }
// identity(2)
// identity("hello")

// interface SearchParams { [key: symbol]: number }
// const abc =  {a:1}
// const params:SearchParams = {
//     [Symbol('foo')]: 222
// }

// interface ObjType {
//     [x:string]: {
//       id: number,
//       text: string,
//       description: string,
//       link: string,
//     }[]
//   }

// const AllDevSitesObj:ObjType = {
//     1:[
//       {
//         id: 1,
//         text: 'Web小白入门',
//         description: '面向零基础的开发小白的第一个web开发入门教程，从零制作并上线一个静态网站。',
//         link: '/tutorials/web/zeroguide/start.html',
//       }
//     ]
//   }


// for(const item in AllDevSitesObj){
//     console.log(AllDevSitesObj[item])
// }

// interface StringArray {
//     [index: string|number]: string;
// }



// const myArray: StringArray = {
//     objec: '22'
// };
// const secondItem = myArray[2]; 
// console.log(secondItem)


// interface Animal {
//   name: string;
// }

// interface Dog extends Animal {
// breed: string;
// }

// // Error: indexing with a numeric string might get you a completely separate type of Animal!
// interface NotOkay {
//     [x: number]: Dog;
//     // 'number' index type 'Animal' is not assignable to 'string' index type 'Dog'.
//     [x: string]: Animal;
// }

// interface NumberOrStringDictionary {
//     [index: string]: Array<string>|number|string
//     length: number; // length 是数字，可以
//     name: string; // name 是字符串，可以

// }

// interface ReadonlyStringArray {
//    readonly  [index: number]: string;
// }

// let myArray: ReadonlyStringArray = {
//     1: 'hello'
// };
// myArray[1] = "Mallory";


// class MyClass {
//     [s: string]: boolean | ((s: string) => boolean);
//     check(s: string) {
//         return this[s] as boolean;
//     }
// }

// const c = new MyClass()
// c.hello = true;
// console.log(c.check('hello'))  //true

// class Horse {

// }
// type OnlyBoolsAndHorses = {
//     [key: string]: boolean | Horse;
// };
// const conforms: OnlyBoolsAndHorses = {    
//     del: true,
//     rodney: false,
//     ss: new Horse()
// };

//-------------------------------------------------

// type OptionsFlags<Type> = {
//     [Property in keyof Type]: boolean;
// }

// type FeatureFlags = {
//     darkMode: () => void;
//     newUserProfile: () => void;
// };

// type FeatureOptions = OptionsFlags<FeatureFlags>;

// //测试
// const test: FeatureOptions = {
//     darkMode: true,
//     newUserProfile: true
// }


//-------------JS JS---------------
// let obj = {
//     toString() {
//       console.log('toString called');
//       return 'Hello';
//     }
// };

// let foo: any = {};
// foo[obj] = 'World'; // toString called
// console.log(foo[obj]); // toString called, World



// -----------------------ts-----------------
// const obj = {
//     toString() {
//       return 'Hello';
//     }
//   };

// const foo: any = {};

// // ERROR: 索引签名必须为 string, number....
// //foo[obj] = 'World';

// // FIX: TypeScript 强制你必须明确这么做：
// foo[obj.toString()] = 'World';


// const foo: {
//     [index: string]: { message: string };
// } = {};

//   // 储存的东西必须符合结构
// // ok
// foo['a'] = { message: 'some message' };

// // Error, 必须包含 `message`
// foo['a'] = { messages: 'some message' };

// // 读取时，也会有类型检查
// // ok
// foo['a'].message;

// // Error: messages 不存在
// foo['a'].messages;


// // ok
// interface Foo {
//     [key: string]: number;
//     x: number;
//     y: number;
// }

// // Error
// interface Bar {
//     [key: string]: number;
//     x: number;
//     y: string; // Error: y 属性必须为 number 类型
// }

// type Index = 'a' | 'b' | 'c';
// type FromIndex = { [k in Index]?: number };

// const good: FromIndex = { b: 1, c: 2 };

// // Error:
// // `{ b: 1, c: 2, d: 3 }` 不能分配给 'FromIndex'
// // 对象字面量只能指定已知类型，'d' 不存在 'FromIndex' 类型上
// const bad: FromIndex = { b: 1,c: 2, d: 3 };


// interface NestedCSS {
//     color?: string;
//     nest?: {
//         [selector: string]: NestedCSS;
//     };
// }

// //OK
// const example: NestedCSS = {
//     color: 'red',
//     nest: {
//         '.subclass': {
//             color: 'blue'
//         }
//     }
// }

// //Error
// const failsSliently: NestedCSS = {
//     colour: 'red'  // TS Error: 未知属性 'colour'
// }

// type FieldState = {
//     value: string;
// };

// type FormState = { isValid: boolean } & { [fieldName: string]: FieldState };

// // 将它用于从某些地方获取的 JavaScript 对象
// declare const foo: FormState;

// const isValidBool = foo.isValid;
// const somethingFieldState = foo['something'];

////使用它来创建一个对象时，将不会工作
//const bar: FormState = {
//     // 'isValid' 不能赋值给 'FieldState'
//     //属性“isValid”与索引签名不兼容。
//     //不能将类型“boolean”分配给类型“FieldState”。
//     isValid: false
//};

const object1: Record<string, string> = { prop: 'Value' }; // OK
const object2: { [key: string]: string } = { prop: 'Value' }; // OK

type Salary = Record<'yearlySalary'|'yearlyBonus'|string, number>
//OK 

const salary1: Salary = { 
    yearlyBonus:1111,
    yearlySalary:222,
    SDSD:22
}; 
